Method for utilizing look and feel in a graphical user interface

ABSTRACT

A method for rendering a graphical user interface (GUI), comprising providing for the representation of the GUI as a set of objects wherein the objects are organized in a logical hierarchy, associating a theme with a first object in the set of objects, rendering the first object according to the theme, rendering any descendents of the first object according to the theme, wherein any descendents of the first object can override the theme, and wherein one of the set of objects can communicate with another of the set of objects.

CLAIM OF PRIORITY

This application claims priority from the following application, whichis hereby incorporated by reference in its entirety:

U.S. application No. 60/450,991, FRAMEWORK FOR A PERSONALIZED PORTAL,Inventors: Daryl Olander, et al., filed on Feb. 28, 2003. (Attorney'sDocket No. BEAS-1374US0)

CROSS REFERENCE TO RELATED APPLICATIONS

This application is related to the following co-pending applicationswhich are each hereby incorporated by reference in their entirety:

U.S. application Ser. No. ______, Inventors: Scott Musson, et al., filedon ______, SYSTEM AND METHOD FOR CONTAINING PORTLETS. (Attorney's DocketNo. BEAS-01366US0)

U.S. application Ser. No. ______, Inventors: Scott Musson, et al., filedon ______, METHOD FOR ENTITLING A USER INTERFACE. (Attorney's Docket No.BEAS-01374US1)

U.S. application Ser. No. ______, Inventors: Daryl B. Olander, et al.,filed on ______, GRAPHICAL USER INTERFACE NAVIGATION METHOD. (Attorney'sDocket No. BEAS-01375US0)

U.S. application Ser. No. ______, Inventors: Scott Musson, et al., filedon ______, METHOD FOR PROVIDING A GRAPHICAL USER INTERFACE. (Attorney'sDocket No. BEAS-01378US0)

U.S. application Ser. No. ______, Inventors: Scott Musson, et al., filedon ______, METHOD FOR PORTLET INSTANCE SUPPORT IN A GRAPHICAL USERINTERFACE. (Attorney's Docket No. BEAS-01382US0)

U.S. application Ser. No. ______, Inventors: Daryl B. Olander, et al.,filed on ______, CONTROL-BASED GRAPHICAL USER INTERFACE FRAMEWORK.(Attorney's Docket No. BEAS-01401US0)

U.S. application Ser. No. ______, Inventors: Daryl B. Olander, et al.,filed on ______, SYSTEM AND METHOD FOR DYNAMICALLY GENERATING AGRAPHICAL USER INTERFACE. (Attorney's Docket No. BEAS-01403US0)

U.S. application Ser. No. ______, Inventors: Daryl B. Olander, et al.,filed on ______, METHOD FOR PROPAGATING LOOK AND FEEL IN A GRAPHICALUSER INTERFACE. (Attorney's Docket No. BEAS-01404US0)

COPYRIGHT NOTICE

A portion of the disclosure of this patent document contains materialwhich is subject to copyright protection. The copyright owner has noobjection to the facsimile reproduction by anyone of the patent documentor the patent disclosure, as it appears in the Patent and TrademarkOffice patent file or records, but otherwise reserves all copyrightrights whatsoever.

BACKGROUND

Developing graphical user interfaces (GUIs) for distributed applicationssuch as web portals can present many challenges. Not only do end-usersexpect to customize the content a given GUI presents to them, they mightalso expect to customize the look and feel of the GUI. Suchcustomization can be coarse-grained, as in changing an overall colorscheme, but they can also be fine-grained wherein an end-user may desireto change the textures, arrangement, behaviors and other characteristicsof the GUI. This presents many design challenges, especially if such aGUI is deployed in a clustered, multi-threaded runtime environment.

FIELD OF THE DISCLOSURE

The present disclosure relates generally to graphical user interfacedevelopment.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is an illustration of an exemplary web graphical user interfacein accordance to an embodiment.

FIG. 2 is an illustration of a web control taxonomy in accordance to anembodiment.

FIG. 3 is an illustration of request processing in an embodiment.

FIG. 4 is diagram of container processing in accordance to oneembodiment.

FIG. 5 is diagram of a control tree factory having a JSP pagedescription implementation in accordance to an embodiment.

FIG. 6 is diagram of a control tree factory having a metadata pagedescription implementation accordance to an embodiment.

FIG. 7 is diagram of a control tree factory having a pure JSP pagedescription implementation accordance to an embodiment.

FIG. 8 is a diagram of a system in accordance to an embodiment.

FIG. 9 is a sample skeleton JavaServer Page in accordance to anembodiment.

DETAILED DESCRIPTION

The invention is illustrated by way of example and not by way oflimitation in the figures of the accompanying drawings in which likereferences indicate similar elements. It should be noted that referencesto “an” or “one” embodiment in this disclosure are not necessarily tothe same embodiment, and such references mean at least one.

FIG. 1 is an illustration of an exemplary web graphical user interfacein accordance to one embodiment of the invention. In one embodiment, byway of example, page 16 is rendered upon display area 12, which can be aregion in the display area of a device for displaying images and/orproducing sounds (e.g., a computer monitor). Page 16 is comprised ofseveral elements. Page selection tabs 20-28 can each be selected by auser to render a different page. Pages can be thought of as panels orpanes that can be swapped into and out of a display region of theavailable portal real estate. By way of a non-limiting example,selection of a GUI element can be accomplished with an input device suchas a mouse, a motion detector, voice commands, hand or eye gestures,etc. If tab 20 were selected, for example, the page corresponding tothat tab could be rendered. Although the tabs 20-28 in FIG. 1 aredisplayed horizontally, in another embodiment the tabs could bedisplayed vertically or using some other suitable scheme such as ahierarchical menu.

Within page 16 is display area 10, which includes portlets (18, 30, 32)and other elements. A portlet is an application that manages its ownGUI. Portlets can communicate with each other and with other softwareand hardware components (e.g., Enterprise Java Beans™, Java™ Beans,servlets, applets, etc.). The Java™ programming language, its libraries,environment, and toolkits are available from Sun Microsystems, Inc. ofSanta Clara, Calif. The other software and hardware components may bepart of the same execution environment as the portlet or may be in adifferent execution environment. In one embodiment, a portlet can beimplemented with JavaServer Pages™. By way of a non-limiting example,portlet 30 displays real-time stock ticker information. A user couldconfigure such a portlet to display certain stocks, for example. Inanother embodiment, the user can select a given stock displayed inportlet 30 and receive more detailed information, such as the pricehistory, price to earnings ratio, etc.

Portlet 30 can handle user input and responding accordingly. Portlet 32displays up-to-date information pertaining to a user's checkingaccounts. Likewise, portlet 32 could provide detailed information ontransactions if the user were to select an account. Advertisementportlet 18 displays an advertisement that could be directed specificallyto the current user based on demographics or other information. Forinstance, if a user had an outstanding home loan in good standing, theadvertisement could be for a home equity loan. Likewise, if the user hadan appropriate amount in a savings account, the advertisement could befor a new car loan. Static area 14 contains text or an image with text.

FIG. 2 is an illustration of a control taxonomy in accordance to anembodiment. One embodiment provides a set of controls that representcorresponding graphical and functional elements in web applications.Controls can have properties that can be read and set, and controls caninteract with each other through an event notification mechanism. Inaddition to properties and events, controls can also have methods whichprovide services and which may be overridden to provide specializationof the control. In one embodiment, a control can be implemented as oneor more classes in an object-oriented programming paradigm. Such anarrangement allows for new properties, events and/or specialized controlmethods to be provided by extending base control classes related tothese features. In a framework, controls can also serve as containersfor other controls. By way of a non-limiting example, a page may containa booklet and a portlet, the booklet may contain one or more pages, theportlet may contain a window, the window may contain a title bar whichmay contain a close button, etc.

At the top of the taxonomy, there can be one or more web applications200. A web application represents a collection of resources andcomponents that can be deployed as a unit in one or more web/applicationservers. In one embodiment, a web application can represent a J2EE (Java2 Platform, Enterprise Edition) Enterprise Application. In variousembodiments, a web application can contain one or more controls 202representing one or more portals. From an end-user perspective, a portalis a website whose pages can be navigated. From an enterpriseperspective, a portal is a container of resources and functionality thatcan be made available to end-users. Portals can provide a point ofaccess to applications and information and may be one of many hostedwithin a web/application server. In one embodiment, a portal can be aJ2EE application consisting of EJB (Enterprise Java Bean) components anda set of Web applications. In another embodiment, a portal can bedefined by an XML (Extensible Markup Language) file. The portal file cancontain all of the components that make up that particular instance,such as booklets, pages, portlets, and look and feel components.

A GUI can contain one or more desktop controls 204. A desktop control inturn can contain one or more personalized views or user views (notshown). A user can have one or more personalized user views of adesktop. In one embodiment, a user view can result from customizing thelayout, content, number, and appearance of elements within a desktop. Adefault user view can be provided for users who have not yet customizeda desktop. A desktop's appearance can be determined by a Look and Feelcontrol 210. The look and feel control can contain a skin component 220and a skeleton component 222. Skins can provide the overall colors,graphics, and styles used by all components in a desktop interface. Inone embodiment, skins can include collections of graphics and cascadingstyle sheets (CSS) that allow changes to be made to the look and feel ofthe GUI without modifying other components directly. References toimages and styles can be made in the skin rather than being hard-codedinto a GUI definition. A look and feel component can provide a path to askin directory to be used.

The look and feel file can also provides a path to the skeletondirectory to be used. Every type of component, from a desktop to aportlet's title bar, can have an associated JSP (Java ServerPages™)file, called a skeleton file, that renders it. For example, each desktopuses a skeleton file called shell.jsp that simply provides the openingand closing <HTML> (Hypertext Markup Language) tags to render thedesktop. A portlet title bar, on the other hand, can have a skeletonfile called titlebar.jsp that is more complex. It contains Java calls tovarious windowing methods in the API, references the button graphics touse on the title bar, and determines the placement of title bar elementswith an HTML table definition.

A desktop also can contain a booklet control 206. A booklet controlrepresents a set of pages linked by a page navigator (menu 214) having auser selectable graphical representation (e.g., a series of tabs whereineach tab corresponds to a different page, a series of buttons, a menu,or other suitable means.) A booklet can provide an indication of thecurrently selected page through visual clues such as highlighting acurrently selected tab, displaying text and/or graphics to indicate thecurrent page, etc. Booklets can be nested to n levels. A booklet canoptionally include a theme control 212. In one embodiment, a themecontrol represents a subset of a skin component and can provide a way ofusing a different set of styles for individual desktop components. Thebooklet control can also contain other booklets 216.

A shell control 208 can render anything surrounding the booklet 206 inthe desktop 204. For example, a shell control might render a desktop'sheader and footer. These areas usually display such things aspersonalized content, banner graphics, legal notices, and related links.

A booklet also contains zero or more page controls 218. A page controlcan represent a web page in an embodiment. A page is an area of a GUIupon which other elements having GUIs, such as booklets and portlets,can be placed. Pages can also contain booklets and other pages, and canbe identified/navigated to by a control such as a menu 214. A pagecontrol can also hold a theme control 224 and a layout control 226. Alayout control determines the physical locations of portlets and otherelements on a page. In one embodiment, a layout is can be implemented asan HTML table.

A layout can contain a placeholder control 228 which is comprised ofindividual cells in a layout in which portlets are placed. A placeholdercan contain zero or more booklets 232 and zero or more portlets 230. Aportlet is a self-contained application that can render its own GUI. Aportlet is a self-contained application that is responsible forrendering its own content on a page. By way of a non-limiting example, aportlet might be a display of current news headlines, wherein if a userselects a headline the portlet retrieves and the underlying story anddisplays it for the user. Portlets can communicate with other portletsand with back-end processes such as legacy software, databases, contentmanagement systems, enterprise business services, etc. In addition,multiple instances of a portlet can execute simultaneously. A portletcan also contain a theme 234.

A control tree can represent a particular instance of the controltaxonomy. In one embodiment, each node in the control tree can be asubclass of a Control class in an object-oriented paradigm. A controltree can be created with both statically created controls anddynamically created controls. Statically created controls are createdduring a construction (or “wire-up”) phase of the control tree and, inone embodiment, can be based on static markup. Dynamically createdcontrols are created during a control tree lifecycle, many times inreaction to state, context, and events. Both kinds of controls cancreate content either dynamically (e.g., by binding to a database table)or statically (e.g., by containing a literal string).

Controls within a control tree can have unique names. In addition,controls can have local names that are qualified into a scope. This canallow for controls to be searched for based upon their “local” namewithin a naming scope. In one embodiment, the system can use a control'sunique name for identifying it in operations such as saving andrestoring state during the cycle of HTML postbacks to the page. Postbackoccurs when a form on a page targets the same page. When the form issubmitted, the second request for the page is called a postback. Thepostback allows the page to handle changes made to data and raise eventsbefore either redirecting to a new page or simply displaying the samepage again. In one embodiment, multiple control scopes can be providedas described in Table 1. TABLE 1 Object Scopes in an Embodiment SCOPEDESCRIPTION Request An object is accessible for the life of the request.Page An object is accessible across subsequent requests to a page. Inone embodiment, a page has a lifetime that can include a postback cycle.Session An object is accessible for the life of the session. (This isavailable for protocols that support session.) Webflow An object isaccessible within a named scope defined by a webflow. A Webflow is a setof states that control navigation from one web page to another.Application An object is accessible globally within the application.

In one embodiment, many of the classes can be sub-classed to providespecializations and custom features. It will be apparent to thoseskilled in the art that many more such classes are within the scope andspirit of the present disclosure. Table 2 provides an overview ofclasses in one embodiment. TABLE 2 Framework Controls in an EmbodimentCLASS/ INTERFACE DESCRIPTION Control The basic framework building block.The base Control class defines a set of services available to allcontrols. This class defines and provides a set of services tosubclasses including lifecycle, naming, and child management. Alifecycle driver will drive the control-tree through a well defined setof states. For a control, the lifecycle is defined by a set of methodsrepresenting stages in the lifecycle. A control can override methods ofthe lifecycle in order to provide specialized behavior. For example,most controls will override beginRender to render its specificrepresentation to an output stream. The stages provide well definedplaces to acquire resources, manage state, raise events, renderthemselves, etc. Most lifecycle stages consist of two methods that arecalled by the lifecycle driver. The naming pattern of the two methods isXxxx and fireXxxx. The Xxxx method is overridden by subclasses tospecialize the lifecycle stage. The fireXxxx method is overridden if acontrol wants to change how the event associated with the lifecyclestage is fired. Lifecycle Defines methods called during the control'slifecycle. There are two methods for most lifecycle events. Thelifecycle method xxx is called first to provide the lifecycle servicefor the control. Then an onXxx method is called to raise an event. Inone embodiment, all of the lifecycle stages prior to rendering raiseevents through the onXxx method. NamingScope The Control and theNamingScope interface interact to provide support for uniquely naming acontrol within a tree. Unique names are generated automatically whencontrols are added to an existing control-tree. Unique names are usedfor state management. Controls have three types of names: Id - This is auser assigned value that should be unique within a name scope. ScopeId -This is a generated name that is unique within a scope. It is either theId or a generated name. UniqueId - This is the globally unique name ofthe control. This name is typically used to identify state and identifythe control within a HTML Form. Context Context is an abstract classproviding services to controls in the tree. In one embodiment, theseservices are protocol-independent. It is the container's responsibilityto create the context object. The container can create an object thatsubclasses Context and provides container aware controls with additionalservices such as information about the framework and or protocol. By wayof a non-limiting example, a container can be a servlet providing aframework. The Context can contain both HTTP-specific information andweb application-specific information. A Portlet control that isportal-aware can cast the Context into the subclass and access theseservices. Well-designed controls, which are aware of one or morecontainers, can be written to work or fail gracefully when they are usedwithin the context of the generic Context. Context provides thefollowing services: Access to the Abstract Data Layer - Context willprovide an object implementing the interface providing an abstract datalayer. Request Type - The Context contains properties indicating whattype of request is happening such as “new request”, “postback”, etc.Request Information - The Context provides information that comes fromthe request such as request parameters, requested URL, etc. Thisinformation may be unavailable for protocols that don't support it.Generic Services - The context allows controls to access and register asservice providers to other controls. For example, a StyleBlock controlmay register as the StyleHandler object that will create a single stylesheet for an output HTML document. Other controls may push styledefinitions into the StyleHandler. These services will typically be usedby a set of framework aware controls and will support things such asstyles, URL rewriting, etc. Renderer Renderer is an interface thatallows a class to be created and which acts as a rendering proxy for acontrol. A control has rendering methods allowing the control to outputits representation into a stream. There are two primary methods forrendering; beginRender( ) and endRender( ). Default rendering can beoverridden by setting a control's renderer by providing an objectimplementing the Renderer interface.

FIG. 3 is an illustration of request processing in an embodiment.Although this figure depicts functional steps in a particular order forpurposes of illustration, the process is not limited to any particularorder or arrangement of steps. One skilled in the art will appreciatethat the various steps portrayed in this figure could be omitted,rearranged, combined and/or adapted in various ways.

In one embodiment, a GUI is rendered in response to a request (e.g., anHTML request originating from a web browser). In step 300, a process(e.g., a web/application server or other suitable process) can acceptthe request and map it to a control tree factory. In step 302, theidentified factory can be used to generate a control tree representingthe GUI. In step 304, the control tree can be evaluated based on thecontents of the request. In doing so, the control tree can be driventhrough a sequence of lifecycles that allow for individual controls inthe tree to, by way of a non-limiting example, process the request,interact with each other and a context provided by the container, andproduce a response. Finally, in step 306 the process can provide aresponse to the sender of the request. In one embodiment, this responsecan contain output for GUI rendering (e.g., HTML or other suitable GUIdescription) from one or more controls.

In one embodiment a container (not shown) can run the control treethrough a sequence of one or more lifecycles by employing the servicesof an interchangeable lifecycle driver (not shown). In one embodiment, acontrol or a container can customize the lifecycle. Customization caninclude removing and/or reordering defined lifecycle stages and/oradding new stages. All of the controls in the control tree canparticipate in the lifecycle, but do not have to. The purpose of thelifecycle is to advance the control tree though a set of states. Thesestates permit controls to obtain their state and resources, raise andhandle events, save their state, communicate with other controls, renderthemselves, and free resources. The lifecycle is external to the controltree and can be provided by the container. This allows for easymodification of the lifecycle.

In one embodiment, controls can register to raise and catch events toperfect inter-control communication. An event mechanism allows controlsto specify (or register for) events that they will raise and/or listenfor. In one embodiment, this can be accomplished with two methods. Amethod named “xxxx” represents the lifecycle method itself and isusually sub-classed to provide specialized behavior for the control. Amethod named “fireXxxx” can be invoked to cause an event notificationthat the lifecycle method xxxx has run on the control. This method canbe overridden to provide specialization of event firing. By way of anon-limiting example, a control could suppress firing of an event byoverriding it and doing nothing. When an event is raised, all controlsthat have registered to receive it will be given an opportunity tohandle the event (e.g., through a call-back mechanism). There is nolimit on the number of events that can be raised or caught. By way of anon-limiting example, a form control could raise an event when a userenters text in a text field of a GUI representation of the form. Thisevent could be caught by a button on the same page as the form. Thebutton could then un-dim itself based on a determination of whether auser entered a valid character sequence into the form.

Controls can be dynamically added to the tree at any stage of thelifecycle up until a pre-render stage. When controls are added to anexisting tree dynamically, these new controls can participate in thefull lifecycle. In one embodiment, a lifecycle catch-up process candrive the new controls through the lifecycle until they catch-up to thecurrent stage. All lifecycle stages before the rendering stage can raiseevents. In one embodiment, a container can implement the lifecyclestages illustrated in Table 3. TABLE 3 Lifecycle Stages in an EmbodimentLIFECYCLE STAGE DESCRIPTION Init Allows a control to performinitialization. Load State Load previously saved state from the request.This state represents the GUI state of the page. Create Child Stage usedto create child controls. Controls Load Obtain external resourcesnecessary for processing the request. If the request is a postback, atthis point the controls' states match their states in the client's view,i.e., saved state has been restored and postback data has been used toupdate controls with new values. Raise Events This is a two phase stagewhere controls first indicate they want to raise events and then allcontrols who indicated this are allowed to raise events. Pre-render Thisis the final stage before the rendering stages. At this point the treeshould be stable and all events processed. Save State This stage is thefirst stage in rendering. All controls that want to save their statesare given the opportunity to do so. Any changes to controls after thispoint cannot affect the saved state. This is the page specific GUIstate. Application level state is managed at a different level. RenderThis is the stage where controls create their GUI representations andcontrol how their children are rendered. Unload This stage allows thecontrol to free resources obtained in Load. Dispose Any final cleanupcan be done.

FIG. 4 is diagram of container processing in accordance to oneembodiment. Although this diagram depicts objects/processes asfunctionally separate, such depiction is merely for illustrativepurposes. It will be apparent to those skilled in the art that theobjects/processes portrayed in this figure can be arbitrarily combinedor divided into separate software, firmware or hardware components.Furthermore, it will also be apparent to those skilled in the art thatsuch objects/processes, regardless of how they are combined or divided,can execute on the same computing device or can be distributed amongdifferent computing devices connected by one or more networks.

A request 410 can be mapped to a control tree factory 402 by container400. In one embodiment, the container use “wire-up” service 404 in thefactory which will cause the factory to return the root of a controltree. In one embodiment, the generation of the control tree is based inpart on the request. The control tree (not shown) produced by controltree factory can be a page level object or can become a sub-tree of alarger control tree. The control tree factory is independent ofcontainer 400 and can be accessed from multiple containers. In oneembodiment, the control tree factory can make modifications to the treesuch as replacing the default rendering or state methods for a control,including for the page itself. In one embodiment, the container canassociate a Context object 408 with the control tree root. A baseContext class can provide generic services to controls in a control treeand can be protocol independent. Generally speaking, a container can beassociated with both a specific protocol and application framework.However, the container can also provide a subclass of Context to exposeprotocol and application-specific objects and services.

FIG. 5 is diagram of a control tree factory having a JSP pagedescription implementation in accordance to an embodiment. Although thisdiagram depicts objects/processes as functionally separate, suchdepiction is merely for illustrative purposes. It will be apparent tothose skilled in the art that the objects/processes portrayed in thisfigure can be arbitrarily combined or divided into separate software,firmware or hardware components. Furthermore, it will also be apparentto those skilled in the art that such objects/processes, regardless ofhow they are combined or divided, can execute on the same computingdevice or can be distributed among different computing devices connectedby one or more networks.

In one embodiment, the framework can support JSP as a page descriptionlanguage. The control tree produced by such an implementation can allowfor full use of JSP features such as tag extensions, scriptlets andexpressions. By way of a non-limiting example, a servlet mapped to theextension “.jsp” can handle all JSP pages 502 mixing JSP and controlsand can act as a container. The servlet can provide a request 516 tofactory 500, which will generate a control tree. The factory can use aJSP parser variant 504 to create a metadata representation of a controltree 508. The parser variant captures the hierarchy of controls and foreach control it recognizes, it can also capture information about theproperties, events, and model binding that have values set in the pagedescription. The parser variant can also capture template text in theJSP page and create metadata representing the template text as literalcontrols. By way of a non-limiting example, tag library extensions canrepresent controls in the JSP page. A standard JSP compiler 506 can alsoprocess the .JSP page and produce a .JSP page implementation class 510that can be used to render JSP in concert with the control tree.

A class 514 is created to process the metadata. The class provides aservice 512 that can be used to instantiate a control tree on behalf ofa container. If the JSP page contains JSP-specific features, the servicecan make use of an inner class that implements a Renderer interface (notshown). The Renderer interface can act as a proxy for rendering of thecontrol tree. In one embodiment, this proxy defers to a _jspService( )method found in the JSP page implementation class. The Rendererinterface treats the page implementation class as a servlet and drivesit through the lifecycle, providing it a servlet context and otherthings needed. Tag extensions can be mapped into the control tree duringthe render lifecycle. The variant parser can create literal controls inthe control tree for instances of template data found in the JSP page.In one embodiment, if a JSP page contains only controls and templatedata, the _jspservice( ) method does not to be invoked.

FIG. 6 is diagram of a control tree factory having a metadata pagedescription implementation accordance to an embodiment. Although thisdiagram depicts objects/processes as functionally separate, suchdepiction is merely for illustrative purposes. It will be apparent tothose skilled in the art that the objects/processes portrayed in thisfigure can be arbitrarily combined or divided into separate software,firmware or hardware components. Furthermore, it will also be apparentto those skilled in the art that such objects/processes, regardless ofhow they are combined or divided, can execute on the same computingdevice or can be distributed among different computing devices connectedby one or more networks.

Referring to FIG. 6, a parser is not relied upon to generate metadatadescribing a control tree. Instead, a metadata representation 606 isassumed to be available as a resource 602 to the factory 600. In oneembodiment, the metadata representation can be an XML document or Javaclass file defined by a schema. The factory has an internal wire-upgenerator 606 that can generate a control tree wireup class 616 based onthe metadata. In this scheme, the rendering can be performed by aRenderer object (not shown) that can defer to a _jspService( ) methodavailable in the JSP page implementation 618, depending on the metadata.In one embodiment, the JSP page implementation is produced by a standardJSP compiler 608.

FIG. 7 is diagram of a control tree factory having a pure JSP pagedescription implementation accordance to an embodiment. Although thisdiagram depicts objects/processes as functionally separate, suchdepiction is merely for illustrative purposes. It will be apparent tothose skilled in the art that the objects/processes portrayed in thisfigure can be arbitrarily combined or divided into separate software,firmware or hardware components. Furthermore, it will also be apparentto those skilled in the art that such objects/processes, regardless ofhow they are combined or divided, can execute on the same computingdevice or can be distributed among different computing devices connectedby one or more networks.

In one embodiment, JSP container 700 drives the control treeinstantiation process with help from a tag library extension that actsas a container of state set on tag attributes that can be pushed intocontrol instances that the tags create. In one embodiment, this processcan be demarcated in a page description file 702 with a pair of tags 704and 712. One or more tags 706 can locate the metadata description of thecontrol tree and create the control tree. Other tag(s) 708 can create acontext for the control tree and drive it through its lifecycle 710 tothe render stage. The container then allows its body content to renderthe page. Then, tag 712 can drive the final portions of the lifecycle.

JSP input can also be supported. One embodiment can utilize a backingfile in addition to the JSP file. The backing file can be a Java classthat lives beside the JSP file and contains two types ofcustomizations: 1) overloaded method and event handling logic; and 2)declarations for all controls inside the control tree that have anidentification property set. Code can be written in overloaded methodssuch that an event handler has access to these controls. The JSP pageextends a Backing class, which gives the wire-up method the ability touse the JSP implementation class as the root of the control tree. Thewire-up method can also insure that the declared controls areinitialized and that event handlers are wired up. In one embodiment, thevariant JSP parser may produce the backing file within the codegenerated to wire up the tree. The wire up can initialize variables inthe backing file and wire-up handlers.

In yet another embodiment, all input can be derived from a JSP file.Code to handle events can be declared (e.g., “<%! . . . %>”) directly inthe JSP file as a method. The wire-up process would insure that theproper method would be called. The same could be done for the controlvariable declarations. In many cases, these declarations would not bewritten and a Model object would act as an event handler. Thus, one canoverride methods on control and handle events in this way.

FIG. 8 is a diagram of a system in accordance to one embodiment.Although this diagram depicts objects/processes as functionallyseparate, such depiction is merely for illustrative purposes. It will beapparent to those skilled in the art that the objects/processesportrayed in this figure can be arbitrarily combined or divided intoseparate software, firmware or hardware components. Furthermore, it willalso be apparent to those skilled in the art that suchobjects/processes, regardless of how they are combined or divided, canexecute on the same computing device or can be distributed amongdifferent computing devices connected by one or more networks.

Referring to FIG. 8, a control container 800 interacts with a client 810through a request and response protocol. The control container canaccept requests from the client and provides responses thereto so thatthe client may refresh its GUI based on any processing inherent in therequest. The control container can map a request to a control factory808 which it will use to generate a control tree representation of theclient GUI (not shown). Controls in the control tree can make use of apersistence interface that acts as a front-end to an interchangeablepersistence driver 806. The persistence interface hides persistenceimplementation details from controls and allows for a flexiblearchitecture where different persistence providers can be “plugged in”as needed. The control container can use an interchangeable lifecycledriver 804 to drive the control tree through a sequence of states sothat the request can be processed. As with the interchangeablepersistence driver, an interface is provided to isolate lifecycle driverimplementation details from the control container. This allows fordifferent lifecycle implementations to be interchanged as needed. One ormore portlet containers 802 are provided to support portlet executionfor those controls in the control tree that have associated portletprocesses/servlets.

Controls have the ability to persist state across HTTP (HypertextTransfer Protocol) requests. A state management API can be provided togive each control in the tree the ability to persist itself beforerendering an HTTP response. When an HTTP submit to the same page isreceived, this saved state can be used to re-hydrate or restore thecontrol tree from its persisted state. Thus, the same state can bemaintained across different instances of the same control tree withminimal effort to the control author. Controls can be persisted using astate management persistence mechanism.

The Context object can provide access to an interface providing an ADL(Abstract Data Layer). The ADL can provide a named binding to objectswithin a specific scope support for object activation and creation,caching, named access, etc. The framework can define a binding languagethat can be used to bind properties on controls to properties onobjects.

In one embodiment, state management can be implemented behind a pair ofinterfaces: ClientStateWriter and ClientStateReader. TheClientStateWriter provides an interface that a control can use to writeany primitive type or object into state management. By way of anon-limiting example, the following methods can be exposed: public voidwriteByte(byte b); public void writeShort(short s); public voidwriteString(String s); public void writeObject(Object o);

At a particular stage in the control tree lifecycle, the control has theopportunity to save its state. In one embodiment, when a control calls asaveState( . . . ) method, the control receives a ControlStateWriterobject into which it can write its state. A control's contract withstate management is that on the page's next submit, the control canre-read this state using the corresponding loadState( . . . ) lifecyclemethod. A control can read the state in the same order in which thestate was written. By way of a non-limiting example, state can be readby using methods defined on the ControlStateReader interface such as:public byte readByte( ); public short readShort( ); public StringreadString( ); public Object readObject( );

A control is aware only that it is receiving an interface against whichto save any of its state. How the state is actually written and where itis stored are left as implementation details to the implementer of thestate management. One approach to state management may be to write thestate into a web page and have the state submitted whenever a form fromthe page is submitted. This approach suffers from problems when theamount of state that is written to the browser is large, though it maykeep the server from having to track large and expensive user sessionobjects. The flexibility of this embodiment is that a web applicationand even a page can be configured to use a particular state managementpolicy for state that a control tree has written into aControlStateWriter. The resulting state could be stored in the client,as mentioned, the database, a cache system, or even the user session. Inone embodiment, state can be written to a page as a hidden field foundin a form.

In one embodiment, a state management implementation consists of aControlStateWriter that writes to a byte array that is Base64 encodedand written to the browser in an input tag within a form tag. When theform is submitted, the state string is contained in the request data andis used to create a ControlStateReader that contains the data for eachcontrol. ControlStateReaders can also be chained such that the containercan find a ControlStateReader for a particular control instance from anynumber of locations that may be in a state reader chain. A reader chainis specified with a list of implementations in an external XML file thatis parsed at runtime.

The organization of controls in a tree can also be persisted. In oneembodiment, it is assumed that some language (e.g., JSP, XML, etc.) canbe used to describe the control tree and that control tree factory canprocess this language and return a representation of the tree. In oneembodiment, the language can describe metadata about the control tree,the hierarchical relationship between controls, property/value pairs forcontrols in the tree, and event handling. In one embodiment, thelanguage can be manipulated as a stream by the framework. A so-calledstreaming control tree can plug into the framework by implementing acontrol tree factory.

In one embodiment, a streaming control tree factory creates a controltree from an XML Stream. By way of a non-limiting example, the XMLstream may be obtained from multiple sources including the file system,a database, a dynamically constructed Document Object Model (DOM) Tree,etc. In one embodiment, a streaming control tree factory first parses anXML document representation of a control tree into a DOM Tree. The XMLdocument can conform to one or more known schemas which define how acontrol tree is described. The DOM tree is then processed to create arepresentation of the control tree. When the streaming control treefactory is asked for an instance of the control tree, the factory willcreate a new instance of the control tree from the representation.

In one embodiment, after an initial control tree is created, JavaSerialization can be used to obtain a serialized (or streamed) view ofthe control tree. When an instance of the streaming control tree isrequested from a control tree factory, the serialized view isdeserialized. In another embodiment, Java™ code generation can be usedto create a class that will create the control tree. In this embodiment,Java™ code is that knows how to create and initialize the control treeis generated. When a streaming control tree is requested from thefactory, the compiled version of Java™ code is executed to obtain thecontrol tree.

In order to increase the performance of controls that use long-runningresources such as EJBs (Enterprise Java Beans), database accesses orexternal site content, portions of the control lifecycle can be modifiedto support running subtree lifecycles in parallel. By way of anon-limiting example, assume there are two controls, A and B, each whichrely on using a long-running resource in their lifecycles. Standardserial lifecycle traversal over these controls will result in total runtime greater than the sum of the run times of the long-runningresources. However, if these two controls could be run in separatethreads, it is likely that the overall runtime will be less than in theserial case.

In one embodiment, two variations of multithreading are enabled forcontrols: preRender multithreading and render multithreading. PreRendermultithreading is the simplest of these, while render multithreading isprobably the more useful for the most common performance needs (e.g.,where external site content is included into the final control treeoutput).

In one embodiment, a multithreaded foundation is shared between the twomultithreading variations. This foundation includes aControlTreeWalkerPool class. This class is used to spawn offControlTreeWalker invocations to process each thread of processingcontrol. Additionally, this class can perform accounting andsynchronization of the spawned workers. When a new worker is created anddispatched, a count can be incremented of the workers still performingtasks. At the completion of a task, a worker can decrement the count.The main calling thread can then use the ControlTreeWalkerPool to waituntil all workers have completed their tasks before continuingprocessing a Lifecycle run.

The ControlTreeWalkerPool can internally use instances of WalkerWorkers,specialized to the type of multithreading to be done. A factory can beused to instantiate a specific type of WalkerWorker, after which a setof thread context information is gathered, including theContextClassLoader and Subject associated with the mainline thread. Theassignment and execution of the tasks for a WalkerWorker is performedusing the Weblogic kernel facilities for running ExecuteRequests onthreads obtained from ExecuteThreadPools. In this case, the eachWalkerWorker implements the ExecuteRequest interface, allowing it to bedispatched to a WLS ExecuteThread.

Once a WalkerWorker has been dispatched to an ExecuteThread, it performstwo additional steps before the actual control tree walk is performed.First, a ContextClassLoader is transferred to the ExecuteThread. Then, aWalkerWorkerPrivilegedAction class object, which implements aPrivilegedExceptionAction, is created and invoked on the current threadusing a Subject saved from the mainline thread. This privileged actionis then used to perform a Security.runAs( ) method so that theWalkerWorker task is performed with the same user security privileges asin the mainline thread. At this point, code specific to the type ofWalkerWorker is executed via a default pattern, where concreteWalkerWorker classes implement the WalkerWorker methodexecuteWalkerWorker.

Multithreaded preRender is useful in cases where a control can performthe long-running portion of its processing without the need toimmediately render its results into the response. This might includecases where EJB's are called or long-running computation is done, theresults of which are then saved for use in the render lifecycle phase.The multithreaded preRender implementation is composed of two pieces: aclass called LifecycleWorker, which extends WalkerWorker, and a modifiedversion of the ControlTreeWalker's walkRecursive( ) method calledwalkRecursivePreRender( ).

In one embodiment, the LifecycleWorker class is actually a genericWalkerWorker that can perform a control sub-tree walk for any arbitrarylifecycle stage. It simply captures the control tree root and thelifecycle stage as arguments to its contructor, then uses a newControlTreeWalker instance to perform a walk on the sub-tree root duringthe threaded execution.

In one embodiment, the walkRecursivePreRender method is a modifiedversion of ControlTreeWalker.walkRecursive, adding the ability to lookfor controls that are marked as preRenderForkable and use theControlTree WalkerPool to dispatch workers for a subtree. Note that onlythe first subtree encountered depth-wise is dispatched in amultithreaded manner, meaning that if a sub-tree dispatched in amultithreaded manner also contains a control marked for preRenderforking, the inner control will not be executed in an additional thread.However, as long as controls marked for multithreaded preRender aren'tdescendants of one another, they will be performed in tandem with eachother and the main tree walk. At the end of the call towalkRecursivePreRender, the ControlTreeWalker pool is used to wait forthe spawned WalkerWorkers to complete their processing before continuingon to the next lifecycle stage.

Multithreaded render is useful in cases where a control's long-runningprocessing requires that the control immediately render into theresponse. The most common case of this is using a RequestDispatcher toinclude content that either itself is long-running, or is from anexternal site. In this case, the implementation is actually composed ofthree components: a ControlRenderQueue, a class called RenderWorker thatextends WalkerWorker, and a modified version of ControlTree Walker.walkRecursive called walkRecursiveRender. A ControlRenderQueue is usedto collect UIControls marked for forkedRender during the pre-renderphase, and to collect the render results of those UIControls after theyare dispatched to ExecuteThreads. This collection marking phase workssimilarly to multithreaded preRender qualification, where only the firstcontrol depth-wise is collected into the render queue.

During the render lifecycle walk, the render queue is processed beforethe main control tree is walked. This processing dispatches all of thequeued controls to a RenderWorker class so that rendering can take placefor each sub-tree in a separate ExecuteRequest. After the processing hasbeen started, the mainline ControlTreeWalker uses theControlTreeWalkerPool to wait until all worker processing has beencompleted. In order to allow control rendering to be'performed onmultiple threads, and to allow this rendering to occur before themainline render, each RenderWorker creates a BufferedJspContext which isset on the sub-tree it will render. Each BufferedJspContext createsBufferedRequest and BufferedResponse objects that are wrappers for theoriginal HttpServletRequest and HttpServletResponse objects,respectively.

BufferedRequest delegates to the underlying wrapped request, except foraccess to request attributes, via overrides of the getAttribute,setAttribute and getAttributeNames methods of ServletRequest.Additionally, BufferedRequest implements a method that can be used totransfer the sequence of setAttribute calls back to the original requestafter all buffered operations are completed. The BufferedRequest isnecessary in the netuix framework because communication between variousincluded portions of a portal, such as between the main portal file andportlet or jsp files, is accomplished by setting context instances intorequest attributes before performing RequestDispatcher includes.

BufferedResponse delegates to the underlying wrapped response, exceptfor operations that affect the response Writer or OutputStream. Calls togetWriter or getOutputStream are instead diverted to instances based onan internal ByteArrayOutputStream that serves to buffer render outputfrom a UIControl. After setting the BufferedJspContext onto a controlsubtree, the RenderWorker initiates a render walk on the control tree.Each control then uses either the BufferedJspContext and its underlyingbuffered request and response objects as normal, or simply uses thewriter object obtained from the buffered response as normal. The usageof these buffered request and response objects are completelytransparent to the rendering controls, and there is no special coding orhandling that is required to use the buffered versions. However, therender code should be thread-safe.

Once all RenderWorker processing is complete, the mainline renderoperation begins. When the ControlTreeWalker worker encounters a controlthat has been previously rendered by a WalkerWorker, instead ofperforming the regular render visit on that control, it uses theControlRenderQueue to obtain the render result for the control, andwrites that data into the result.

In one embodiment, look and feel (“L&F”) is inherent in an application'sGUI. The elements of a GUI that allow a user to functionally interactwith it comprise the “feel” of L&F. By way of a non-limiting example,these might be windows, menus, buttons, text fields, etc. The generalappearance of these elements comprise the “look” of L&F. By way of anon-limiting example, a look can consist of a button image, the color ofa menu, the font in which text is displayed, etc. Thus, a given GUI“feel” may have more than one “look”, and vice versa.

In one embodiment, L&F includes three components: a LookAndFeel control,one or more skins, and one or more skeletons. The LookAndFeel controlassociates a skeleton with a skin (and other configuration attributes).Skins specify superficial information for a GUI element and provide ameans for an GUI to embrace different “looks” while retaining the corefunctionality laid out by the skeleton (which provides the “feel”). Askeleton provides the general appearance and functioning of a GUIelement. A skeleton is married to a skin at render time to perfect its“look”. In one embodiment, a skeleton includes one or more JSP files.The JSPs that together constitute a given skeleton can be assembled in adirectory, the name of which is used to identify the skeleton.References to the skeleton can be made by referencing the containingdirectory and that directory's path if it differs from a default path(e.g., “/framework/skeletons”). Furthermore, a default skeleton can beprovided (e.g., named “default”) and located in a default skeleton path.In the absence of skeleton settings to the contrary, the defaultskeleton in the default location can be assumed by the framework.

In one embodiment, a skeleton can be used to render HTML content. Inanother embodiment, skeletons can be used to render anything that can berendered by a JSP. In yet another embodiment, a skeleton can render anyof the several forms of XML, either standard or custom (e.g., XHTML,custom XML consumed by Flash MX by Macromedia, etc.). In one embodiment,a skeleton can include a set of JSP files, each of which can beassociated with a particular control (sub-classed fromPresentationControl) in a control tree.

The PresentationControl superclass provides default rendering using askeleton in the absence of more explicit rendering. PresentationControlis a superclass for most framework controls, including (but not limitedto) the following: Desktop, Shell, Head, Body, Header, Footer, Book,SingleLevelMenu, Page, Layout, Placeholder, Window, Titlebar, andToggleButton. In one embodiment, for each PresentationControl there isat least one skeleton JSP defined. Situations may arise where a skeletonJSP provided by the chosen skeleton does not meet the needs of aparticular instance of a PresentationControl. In this case, the skeletonJSP can be overridden with content from a universal resource identifier(“URI”).

In one embodiment, a skeleton JSP's structure is oriented toward controlrendering. Like a control, there are both begin and end render states.In the JSP these phases are represented as “beginRender” and “endRender”tags from a JSP render tag library. In general, the contents of thesetags are rendered in turn with a control's children rendered in between.However, much finer-grained control can be achieved if desired. Specificchildren can be retrieved and rendered in explicit locations in order toprovide maximum structural layout potential.

FIG. 9 is a sample skeleton JavaServer Page in accordance to anembodiment. In one embodiment, the skeleton can handle the skin portionof the L&F by either hard-coding the appropriate look, or even byproviding and using another mechanism of its own. By way of anon-limiting example and with reference to FIG. 9, the “render” taglibis responsible for multiple functions. The “beginRender” and “endRender”sections delimit which code is rendered before child rendering(beginRender) and which code is rendered after child rendering(endRender). Child rendering occurs between the two unless a child isrendered explicitly with the renderChild tag. Here, the renderChild tagis used to render a titlebar child. The titlebar can be retrieved as aPresentationContext, which is a read-only facade over the actual controlbeing rendered. In one embodiment, a PresentationContext exists for eachchild in the current context, and can be accessed as illustrated in theexample JSP.

In one embodiment, skins provide a way to alter the overall look of GUIwithout modifying it's fundamental functionality. The definition of askin can depend on how the skeleton or skeletons it expects to be usedwith are defined. By way of a non-limiting example, if a skeleton isdefined to use a particular cascading style sheet (CSS) class, then theskin needs to define a corresponding rule for that class. Skins can beidentified by the directory in which they live. References to the skincan be made by referencing the containing directory and that directory'spath if it differs from a default path (e.g., “/framework/skins”).Furthermore, a default skin can be provided named “default” and locatedin the default skin path. In the absence of skin settings to thecontrary, the default skin in the default location is assumed by therendering system.

A skin can be described by a properties file (e.g., a file named“skin.properties”) located in the root level of it's containingdirectory. The properties file can associate the skin with resources.The property images.path can be used to specify a location whereskin-related images can be found. Subdirectories of this directory canbe used to store alternate image sets for use by themes. In oneembodiment, this property is optional and defaults to the value“images”. For example, a properties file might include the followingdefinition:images.path: images

A link entries section of the properties file can be used to configurelink entries, such as CSS references. Such entries are generallyHTML-oriented, but could be used by an alternate rendering scheme (e.g.XML) in a way parallel to that described herein. Property entries forthis section essentially encapsulate an HTML “link” tag. In oneembodiment, this can be accomplished as follows:

-   -   (1) All entries for this section begin with the property prefix        “link” to scope them as describing link tags    -   (2) A short name is used to group properties related to a single        tag name    -   (3) Together, (1) and (2) define a link tag to be generated    -   (4) Finally, the base property prefix formed by the union of (1)        and (2) is used to define attributes to be set for the given        link tag by appending a value for any valid HTML link tag        attribute (e.g., charset, href, hreflang, type, rel, media,        etc.)    -   (5) The union of (1)-(4) yields a complete property name usable        in this section; as long as at least one attribute is specified        with a value in a given link group

An “index” link attribute can be included. This attribute is notrendered in the HTML output, but is instead used to determine the orderof the output with respect to link tags representing other propertygroups. In one embodiment, the index attribute can be any integer value.Rendering of indexed property groups will occur in ascending order, withany remaining, un-indexed groups being rendered last in an arbitraryorder relative to one another. This attribute is optional.

For example, these properties: link.document.href: css/document.csslink.document.rel: stylesheet link.document.media: screenlink.document.index: 2 link.input.href: css/input.css link.input.rel:stylesheet link.input.media: screen link.input.index: 1

. . . can generate the following HTML: <link href=“{qualified skinpath}/css/input.css”   rel=“stylesheet” media=“screen”/> <linkhref=“{qualified skin path}/css/document.css”   rel=“stylesheet”media=“screen”/>

In one embodiment, script entries can be placed in a “script entries”section. This section can be used to configure script entries, such asJavaScript references. Property entries for this section essentiallyencapsulate an HTML script. By way of a non-limiting example, this canbe accomplished as follows:

-   -   (1) Entries for this section can begin with the property prefix        “script” to scope them as describing script tags.    -   (2) A short name can be used to group properties related to a        single tag name.    -   (3) Together, (1) and (2) define a script tag to be generated.    -   (4) Finally, the base property prefix formed by the union of (1)        and (2) can be used to define attributes to be set for the given        script tag by appending a value for any valid HTML script tag        attribute (e.g., carset, type, src, defer, etc.).    -   (5) The union of (1)-(4) yields a complete property name usable        in this section; as long as at least one attribute is specified        with a value in a given script group

An “index” script attribute can be included. This attribute is notrendered in the HTML output, but is instead used to determine the orderof the output with respect to script tags representing other propertygroups. The index value can be any integer value. Rendering of indexedproperty groups will occur in ascending order, with any remaining,unindexed groups being rendered last in an arbitrary order relative toone another. This attribute is optional.

For example, these properties: script.skin.src:  js/skin.jsscript.skin.type: text/javascript script.skin.index: 2 script.util.src: js/util.js script.util.type: text/javascript script.util.index: 1

. . . can generate this HTML: <script src=“{qualified skinpath}/js/util.js”   type=“text/javascript”></script> <scriptsrc=“{qualified skin path}/js/skin.js”  type=“text/javascript”></script>Script hrefs can be defined relative to the “skin.properties” file.

In one embodiment, the properties document body onload anddocument.body.onunload allow a skin to associate a “body” tag's “onload”and “onunload” with event handlers. Doing so will cause the value ofeither property to be inserted into the beginning of the appropriateevent handler's command list before rendering. The end result is theevaluation of said property value after the document has been completelyloaded, allowing skin scripts to apply themselves to the document.Typically, the values of these properties are script function callsdefined in one of the script declarations from the previous section. Forexample, this property:

-   -   document.body.onload: addSkinEventHandlers( )    -   . . . will generate this HTML:    -   <body onload=“addSkinEventHandlers( );”>

If a skin was written to be used specifically with a particular skeletonimplementation, the properties default.skeleton.id anddefault.skeleton.path can be set to specify that skeleton. In theabsence of skeleton or skeletonPath attributes of the L&F control thevalues of these properties is used instead of the catch-all defaultskeleton and skeletonPath. The path property can be defined relative tothe webapp.

Metadata can be predefined by setting the property enable.meta.info. Acommon use for this data is as a convenience for testing or debugging.For example, adding information about the look and feel in use can aidin test development in that the tests can identify the document stylebeing handled and can adjust it's testing methodologies or reporting asappropriate. In one embodiment, this data manifests in HTML as a seriesof <metal>tags located in the document head. Absence of this property orany value other than “true” will yield a false setting, which will mutethe output of such meta info.

The resources provided by the skin define what it is, though it's theskeleton and the skin.properties file that bring form to thoseresources, making them tangible. A skin can consist of any number ofresources, and of any type that the target skeleton(s) can takeadvantage of. The following is a list of several of the most commontypes, and some notes about their manifestation as elements of a skin.

In one embodiment, a web application can have an images directoryassociated with it via the Look and Feel, whether or not the imagesproperty was specified in the skin.properties file. Of course, if theskeleton never references any images, then no images are used. Theimages directory can also be set to be equal to the skin directoryitself, which is done by setting the skin.properties propertyimages.path to the empty string.

The following set of images are well-known and, while not strictlyrequired, are typically provided by most skins (since most skeletonsmake use of them). Additional images can be required depending on therequirements of the target skeleton and whether the skin itself definesany of its own images, perhaps via CSS or JavaScript.titlebar-button-config.gif titlebar-button-config-exit.giftitlebar-button-delete.gif titlebar-button-edit.giftitlebar-button-edit-exit.gif titlebar-button-help.giftitlebar-button-help-exit.gif titlebar-button-maximize.giftitlebar-button-unmaximize.gif titlebar-button-minimize.giftitlebar-button-unminimize.gif

Another component of modern Web sites is the Cascading Style Sheet.Skins are able to strongly leverage their decoupling from skeletons byputting CSS to work. While not required, CSS can be the meat andpotatoes of making a skin work. Of course, they won't work gracefullyjust because the skin wants them to—the skin's target skeleton(s) willneed to provide the appropriate hooks (typically in the form of id andclass declarations) for them to be maximally effective.

Note, too, that some skeletons allow control-overridden CSS styles andclasses via the control declaration in a web application source file.Either situation can cause rendering anomolies (which is usually thepurpose of the overrides) that affect the Look and Feel's appearance.Look for this if incorrect rendering behavior seems to appear in the webapplication.

Scripts can be a powerful ally for client-side dynamic behaviors.Typically manifesting as JavaScript or another ECMAScript-compliantlanguage, client-side scripting can be bootstrapped from the webapplication's skin. Great amounts of additional interactivity can beadded, with or without the help of the underlying skeleton code. Forinstance, using the skin.properties property document.body.onload and ascript declaration one can initialize an entire document to suit aparticular purpose or purposes. Suppose it was desired that allwell-defined buttons found in window titlebars had a simple rollovereffect achieved by swapping images during mouse overs. The followingexample code makes that simple, and it can all be specified from theskin itself.

For the example, assume that the standard set of images exist in theskin, along with a new version of each named with the indicator“-active” right before the image file extension, as the next exampleillustrates: titlebar-button-config.giftitlebar-button-config-active.gif

Themes can be defined and implemented across skeletons and skins toprovide variations of either in explicitly defined contexts. Explicitportions of a GUI can take direct control over the L&F of a renderedregion and work within or step outside of the L&F framework describedherein; this is accomplished by overriding skeleton infrastructure forparticular elements (controls). A theme is a construct that allowssubgroups of a portal instance to use different virtual look and feelsthan the main rendering area. Themes can be useful for creatingspecialized areas of the portal that would otherwise complicate thebaseline look and feel development unnecessarily.

For a skin to be useful to a given skeleton (since skins are typicallywritten for particular skeletons) in the context of a particular theme,the skin can support the same set of themes as the skeleton it naturallytargets. In one embodiment, given the name of a theme, the LookAndFeelcontrol searches for theme skeleton components in the directory derivedby combining the base directory of the skeleton and the name of thetheme. Skin theme image resolution works the same way, only using theconfigured images directory for the skin as the base location.

In the skeleton case, themes manifest as sets of skeleton JSPs in theirtheme subdirectory as described above. The sets can be complete sets orsubsets of the base JSP set for the skeleton. In the case of subsets, noupward resolution is performed if a theme's skeleton JSP is missing—thisis an error condition. Any JSP in the theme set is simply a variation onthe base skeleton and is used instead of the base skeleton JSP when thetheme's scope is in effect.

A Theme control manifests as a wrapper around other controls andentities. By applying a theme in this way, the theme's children arerendered with the skeleton and skins resources defined by the envelopingtheme. The following attributes are particularly noteworthy elements oftheme control: “name”, “usingAltSkeleton”, and “usingAltImages”. The“name” attribute is already well known—it defines the unique id as wellas the skeleton and skin images subdirectories used when resolving atheme context.

The “usingAltSkeleton” attribute is a boolean switch; a value of “false”indicates that the Look and Feel should not try to use skeleton JSPsfrom a subdirectory of the base skeleton directory—it should instead usethe default skeleton JSPs. A value of “false” can be useful when onlythe skin side of the theme is of interest to the region of code beingthemed. The default value is “true”.

The “usingAltImages” attribute is a boolean switch as well; a value of“false” indicates that image resources should not be pulled from thetheme-defined subdirectory of the skin images directory, but shouldinstead be pulled from the normal images area. A value of “false” can beuseful when only the skeleton side of the theme is of interest to theregion being themed. The default value is again “true”.

EXAMPLE

<netuix:theme name=“MyTheme” usingAltSkeleton=“false”>   <netuix:window...>     ...   </netuix:window> </netuix:theme>In this simple case, the enveloped window control instance would berendered with the skeleton and skin resources identified by the themenamed “MyTheme”.

The crux of the concepts, implementations, and controls discussed so faris the LookAndFeel control. The LookAndFeel control has the followingattributes in one embodiment:

-   -   skeleton    -   skeletonPath    -   skin    -   skinPath    -   defaultWindowlcon    -   defaultWindowIconPath

In one embodiment, a user can customize (or personalize) a webapplication to suit their needs. A template is a definition of a webapplication and can reside in a library. Changes made to a template canbe propagated to portlet instances, at the discretion of theadministrator. Streaming control trees allow for personalizedrepresentations of requests. For example, a page can contain onlyportlets (controls trees) that the user has selected or that entitlementrules have selected for the user. Each user may select different sets ofportlets. A streaming control tree factory can map each user into anindividual control stream and then construct a control tree from it. Thestreaming control tree factory hides all the details about how thecontrol tree is generated and how personalization occurs. The controltree representation may be cached and may be regenerated if the streamchanges. For example, if a user selects a different set of portlets tobe visible.

In one embodiment, a user's attributes (e.g., name, age, position, etc.)and/or group membership can be used to automatically choose a L&F. Byway of a non-limiting example, when a user first visits a portal, theuser is considered an anonymous visitor and thus will see a default L&Ffor the portal. Once a user logs into the portal, a L&F can beautomatically applied to the portal based on the user's characteristicsor other information (e.g., time of day, external data, etc.).

One embodiment may be implemented using a conventional general purposeor a specialized digital computer or microprocessor(s) programmedaccording to the teachings of the present disclosure, as will beapparent to those skilled in the computer art. Appropriate softwarecoding can readily be prepared by skilled programmers based on theteachings of the present disclosure, as will be apparent to thoseskilled in the software art. The invention may also be implemented bythe preparation of integrated circuits or by interconnecting anappropriate network of conventional component circuits, as will bereadily apparent to those skilled in the art.

One embodiment includes a computer program product which is a storagemedium (media) having instructions stored thereon/in which can be usedto program a computer to perform any of the features presented herein.The storage medium can include, but is not limited to, any type of diskincluding floppy disks, optical discs, DVD, CD-ROMs, microdrive, andmagneto-optical disks, ROMs, RAMs, EPROMs, EEPROMs, DRAMs, VRAMs, flashmemory devices, magnetic or optical cards, nanosystems (includingmolecular memory ICs), or any type of media or device suitable forstoring instructions and/or data.

Stored on any one of the computer readable medium (media), the presentinvention includes software for controlling both the hardware of thegeneral purpose/specialized computer or microprocessor, and for enablingthe computer or microprocessor to interact with a human user or othermechanism utilizing the results of the present invention. Such softwaremay include, but is not limited to, device drivers, operating systems,execution environments/containers, and user applications.

The foregoing description of the preferred embodiments of the presentinvention has been provided for the purposes of illustration anddescription. It is not intended to be exhaustive or to limit theinvention to the precise forms disclosed. Many modifications andvariations is apparent to the practitioner skilled in the art.Embodiments were chosen and described in order to best describe theprinciples of the invention and its practical application, therebyenabling others skilled in the art to understand the invention, thevarious embodiments and with various modifications that are suited tothe particular use contemplated. It is intended that the scope of theinvention be defined by the following claims and their equivalents.

1. A method for rendering a graphical user interface (GUI), comprising:providing for the representation of the GUI as a set of objects whereinthe objects are organized in a logical hierarchy; associating a themewith a first object in the set of objects; rendering the first objectaccording to the theme; rendering any descendents of the first objectaccording to the theme; wherein any descendents of the first object canoverride the theme; and wherein one of the set of objects cancommunicate with another of the set of objects.
 2. The method of claim 1wherein: one of the set of objects can respond to an event raised byanother of the set of objects.
 3. The method of claim 1 wherein: acontrol can have an interchangeable persistence mechanism.
 4. The methodof claim 1 wherein: a control can have an interchangeable renderingmechanism.
 5. The method of claim 1, further comprising: accepting arequest.
 6. The method of claim 5 wherein: the request in a hypertexttransfer protocol (HTTP) request.
 7. The method of claim 5 wherein: therequest originates from a Web browser.
 8. The method of claim 1, furthercomprising: generating a response.
 9. The method of claim 1 wherein: anobject can represent one of: button, text field, menu, table, window,window control, title bar, pop-up window, check-box button, radiobutton, window frame, desktop, shell, head, body, header, footer, book,page, layout, placeholder, portlet and toggle button.
 10. The method ofclaim 1 wherein: associating the theme with the first object can occurwhen the first object is rendered.
 11. The method of claim 1 wherein:the first object inherits the theme from a parent object.
 12. The methodof claim 1 wherein: the theme specifies the appearance and/orfunctioning of an object in the GUI.
 13. The method of claim 1 wherein:rendering the first object according to the theme can be accomplished inparallel with rendering of other objects.
 14. The method of claim 1wherein: the theme can be specified in whole or in part by a propertiesfile.
 15. The method of claim 14 wherein: the properties file caninclude at least one of: 1) cascading style sheet; 2) Java Server Page;3) Extensible Markup Language; 4) text; 5) Hypertext Markup Language; 6)Extensible Hypertext Markup Language; 7) JavaScript; and 8) Flash MX.16. The method of claim 14 wherein: the properties file can specify atleast one image.
 17. The method of claim 1 wherein: the GUI is part of aportal on the World Wide Web.
 18. A method for rendering a graphicaluser interface (GUI), comprising: W accepting a request; mapping therequest to a set of objects that represent the GUI, and wherein theobjects are organized in a logical hierarchy; associating a theme with afirst object in the set of objects; rendering the first object accordingto the theme; rendering any descendents of the first object according tothe theme; and wherein any descendents of the first object can overridethe theme.
 19. The method of claim 18 wherein: the request in ahypertext transfer protocol (HTTP) request.
 20. The method of claim 18wherein: the request originates from a Web browser.
 21. The method ofclaim 18, further comprising: generating a response.
 22. The method ofclaim 1 wherein: one of the set of objects can respond to an eventraised by another of the set of objects.
 23. The method of claim 1wherein: a control can have an interchangeable persistence mechanism.24. The method of claim 1 wherein: a control can have an interchangeablerendering mechanism.
 25. The method of claim 18 wherein: an object canrepresent one of: button, text field, menu, table, window, windowcontrol, title bar, pop-up window, check-box button, radio button,window frame, desktop, shell, head, body, header, footer, book, page,layout, placeholder, portlet and toggle button.
 26. The method of claim18 wherein: associating a theme with the first object can occur when thefirst object is rendered.
 27. The method of claim 18 wherein: the firstobject inherits the theme from a parent object.
 28. The method of claim18 wherein: the theme specifies the appearance and/or functioning of anobject in the GUI.
 29. The method of claim 18 wherein: rendering thefirst object according to the theme can be accomplished in parallel withrendering of other objects.
 30. The method of claim 18 wherein: thetheme can be specified in whole or in part by a properties file.
 31. Themethod of claim 30 wherein: the properties file can include at least oneof: 1) cascading style sheet; 2) Java Server Page; 3) Extensible MarkupLanguage; 4) text; 5) Hypertext Markup Language; 6) Extensible HypertextMarkup Language; 7) JavaScript; and 8) Flash MX.
 32. The method of claim30 wherein: the properties file can specify at least one image.
 33. Themethod of claim 18 wherein: the GUI is part of a portal on the WorldWide Web.
 34. A method for rendering a graphical user interface (GUI),comprising: providing for the representation of the GUI as a pluralityof objects wherein the objects are organized in a logical hierarchy;associating a first theme with a first object in the plurality ofobjects; rendering the first object according to the first theme;associating a second theme with a second object in the plurality ofobjects; rendering the second object according to the second theme; andwherein the second object is a descendant of the first object.
 35. Themethod of claim 34, further comprising: accepting a request.
 36. Themethod of claim 35 wherein: the request in a hypertext transfer protocol(HTTP) request.
 37. The method of claim 35 wherein: the requestoriginates from a Web browser.
 38. The method of claim 34, furthercomprising: generating a response.
 39. The method of claim 1 wherein:the first object can respond to an event raised by the second object.40. The method of claim 1 wherein: an object can have an interchangeablepersistence mechanism.
 41. The method of claim 1 wherein: an object canhave an interchangeable rendering mechanism.
 42. The method of claim 34wherein: an object can represent one of: button, text field, menu,table, window, window control, title bar, pop-up window, check-boxbutton, radio button, window frame, desktop, shell, head, body, header,footer, book, page, layout, placeholder, portlet and toggle button. 43.The method of claim 34 wherein: the first object inherits the firsttheme from a parent object.
 44. The method of claim 34 wherein: thefirst theme specifies the appearance and/or functioning of the firstobject in the GUI.
 45. The method of claim 34 wherein: the rendering thefirst object can be accomplished in parallel with the rendering of thesecond object.
 46. The method of claim 34 wherein: a theme can bespecified in whole or in part by a properties file.
 47. The method ofclaim 46 wherein: the properties file can include at least one of: 1)cascading style sheet; 2) Java Server Page; 3) Extensible MarkupLanguage; 4) text; 5) Hypertext Markup Language; 6) Extensible HypertextMarkup Language; 7) JavaScript; and 8) Flash MX.
 48. The method of claim46 wherein: the properties file can specify at least one image.
 49. Themethod of claim 34 wherein: the GUI is part of a portal on the WorldWide Web.
 50. A machine readable medium having instructions storedthereon that when executed by a processor cause a system to: provide forthe representation of the GUI as a set of objects wherein the objectsare organized in a logical hierarchy; associate theme with a firstobject in the set of objects; render the first object according to thetheme; render any descendents of the first object according to thetheme; wherein any descendents of the first object can override thetheme; and wherein one of the set of objects can communicate withanother of the set of objects.
 51. The machine readable medium of claim50 wherein: one of the set of objects can respond to an event raised byanother of the set of objects.
 52. The machine readable medium of claim50 wherein: a control can have an interchangeable persistence mechanism.53. The machine readable medium of claim 50 wherein: a control can havean interchangeable rendering mechanism.
 54. The machine readable mediumof claim 50, further comprising instructions that when executed causethe system to: accept a request.
 55. The machine readable medium ofclaim 54 wherein: the request in a hypertext transfer protocol (HTTP)request.
 56. The machine readable medium of claim 54 wherein: therequest originates from a Web browser.
 57. The machine readable mediumof claim 50, farther comprising instructions that when executed causethe system to: generate a response.
 58. The machine readable medium ofclaim 50 wherein: an object can represent one of: button, text field,menu, table, window, window control, title bar, pop-up window, check-boxbutton, radio button, window frame, desktop, shell, head, body, header,footer, book, page, layout, placeholder, portlet and toggle button. 59.The machine readable medium of claim 50 wherein: associating the themewith the first object can occur when the first object is rendered. 60.The machine readable medium of claim 50 wherein: the first objectinherits the theme from a parent object.
 61. The machine readable mediumof claim 50 wherein: the theme specifies the appearance and/orfunctioning of an object in the GUI.
 62. The machine readable medium ofclaim 50 wherein: rendering the first object according to the theme canbe accomplished in parallel with rendering of other objects.
 63. Themachine readable medium of claim 50 wherein: the theme can be specifiedin whole or in part by a properties file.
 64. The machine readablemedium of claim 63 wherein: the properties file can include at least oneof: 1) cascading style sheet; 2) Java Server Page; 3) Extensible MarkupLanguage; 4) text; 5) Hypertext Markup Language; 6) Extensible HypertextMarkup Language; 7) JavaScript; and 8) Flash MX.
 65. The machinereadable medium of claim 63 wherein: the properties file can specify atleast one image.
 66. The machine readable medium of claim 50 wherein:the GUI is part of a portal on the World Wide Web.
 67. A computer datasignal embodied in a transmission medium, comprising: a code segmentincluding instructions to provide for the representation of the GUI as aset of objects wherein the objects are organized in a logical hierarchy;a code segment including instructions to associate theme with a firstobject in the set of objects; a code segment including instructions torender the first object according to the theme; a code segment includinginstructions to render any descendents of the first object according tothe theme; wherein any descendents of the first object can override thetheme; and wherein one of the set of objects can communicate withanother of the set of objects.